package com.qf.day01;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 *   Lock：可重入    悲观锁： 读的要上锁 写的也上锁   乐观锁： 读的不上锁 写上锁
 *     底层：
 *
 *       private int state;  // 默认 state=0   未上锁  --》 1 上锁 -- 》2 上锁 --> 3 上锁
 *       3 --》 解锁 2 --》 1  --》 0 未上锁
 *
 *       乐观锁： 底层  CAS 比较与交换
 *
 *    Lock: 公平锁  public static final Lock lock = new ReentrantLock(true);
 *       先到先得  等待时间比较长   等待时间最长的线程拥有锁
 *
 *    锁的种类：
 *      1、不见不散的锁   线程一直阻塞在加锁的位置  lock.lock();
 *      2、// 过期不候的锁  lock.tryLock();
 *
 *
 * @author lixu
 */
public class LockDemo {

    public static final Lock lock = new ReentrantLock();//非公平

    public static void main(String[] args) {



        LockDemo lockDemo = new LockDemo();
        //for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                lockDemo.a();
            }).start();
        //}




    }
    public void a(){
        lock.lock();//第一把  //不见不散的锁

        try {
            boolean isHaveLock = lock.tryLock(1, TimeUnit.HOURS);// 过期不候的锁
            if(isHaveLock){
                //获取到了锁
                // 查询Mysqsl
                // 保存缓存一份

            }else{
                //未获取到锁

                //查询缓存

            }


        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        System.out.println("a");
        b();
        lock.unlock();

    }
    public void b(){
        lock.lock();//第二把

        System.out.println("b");

        lock.unlock();

    }
}
